package leetcode;

import com.demo.linknode.Node;

import java.util.List;

public class TestLinkNode {
    /**
     * 迭代方式
     * @param head
     * @return
     */
    public static  ListNode reverseList(ListNode head) {
        ListNode first = head;
        ListNode reverseHead = null; //建立一个新的节点用来存放结果，反转的头节点
        while (first != null) { //遍历输入链表，开始处理每一个节点
            ListNode second = first.next; //先处理第一个节点first，所以需要一个指针来存储first的后继

            first.next = reverseHead; //将first放到新链表头节点的头部，（因为把cur把当前节点放到头节点前面去了）
            reverseHead = first; // 将first（当前节点）放到新链表头节点的头部。（最后一个节点就是最新的头节点了）

            first = second; //继续处理原链表的节点，即之前指针存放的后继，循环往复，
        }
        return reverseHead;
    }


    //迭代法
    public static ListNode reverseList2(ListNode first) {
        // 定义一个新的链表节点，这个节点永远指向的是一个最新的头节点；
        ListNode revertHead = null;

        //定义当前的节点
        ListNode cur = first;

        while (cur != null) {
            //把下一个要迭代的节点先拿出来，
            ListNode next = cur.next;

            //2,3 都是最新的头部有关系，基本上没操作以前的那个链表了，那个链表，只是做为循环数据了；

            //新的链表的操作
            //2 把当前节点下一个指向新的链表头部B->A
            cur.next = revertHead;
            //3 把当前节点放到新的链表的头部
            revertHead = cur; //B 就是最新的头部了

            //下个迭代开始
            cur = next;
        }
        return  revertHead;

    }


    //first 就是pre
   public static ListNode digui(ListNode cur,ListNode revertHead){
      //拿到最后一个节点，然后从后往前便利；
       ListNode next = cur.next;
       ListNode cur0 = null;
      if(next!= null){
           cur0 = digui(next,revertHead);
          if(next.getNumber() == cur0.getNumber()){
              System.out.println("cur:"+cur.getNumber()+",curO:"+cur0.getNumber());
          }
          //revertHead.next = cur0;//revertHead 永远指向1；
      }else{
          //最后一个节点
          revertHead = cur;
      }
      return cur0;
    }


    //first 就是pre
    //递归得到的底层的返回数据是一样的。
    //cur0 返回都是底层的2
    public static ListNode digui(ListNode cur){
        //拿到最后一个节点，然后从后往前便利；
        ListNode next = cur.next;
        ListNode cur0 = null;
        if(next!= null){
            cur0 = digui(next);
            System.out.println("cur:"+cur.getNumber()+",cur0:"+cur0.getNumber());
            if(next.getNumber() == cur0.getNumber()){
                System.out.println("cur:"+cur.getNumber()+",curO:"+cur0.getNumber());
            }
            //1需要在这里加一部
            next.next = cur;
            cur.next = null;
            return cur0; //2在这里返回等层的节点
            //revertHead.next = cur0;//revertHead 永远指向1；
        }else{
            return cur;
        }
    }

    /**
     * 1 递归获取到最后一个节点，然后依次把after.next =head;
     * head.next = null;
     * @param head
     * @return
     */
    public static  ListNode reverseDigui(ListNode head) {
        //遇到最后一个节点返回
        if (head == null || head.next == null){
            return head;
        }
        //递归知道最后一个节点返回，前面的递归都会返回这个节点的值
        ListNode newHead = reverseDigui(head.next);
        System.out.println("newHead:"+newHead.getNumber());
        //从后往前设置调用链，0,1,2
        //1的时候，after 2: 2的next 就为1了，1的next 为0
        //0的时候 after 1, 1的next 为0,0的next 为null;
        head.next.next = head;
        head.next = null;
        return newHead;
    }

    public static void testRef(ListNode head){
        System.out.println("head:指针："+head);
        head = null;
        System.out.println("改变head:指针："+head);
    }


    public static void main(String[] args) throws  InterruptedException {
        ListNode head = new ListNode(0);
//        System.out.println("引用传递之前的指针；"+head);
//        testRef(head);
//        System.out.println("引用传递之前的指针之后；"+head);
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        head.setNext(node1);
        node1.setNext(node2);
        node2.setNext(node3);
        ListNode newHead = reverseDigui(head);
        //digui(head,newHead);
        //ListNode newHeadOther  = reverseDigui(head);
        printData(newHead);
    }

    private static void printData(ListNode node){
        System.out.println("printData:"+node.getNumber());
        if(node.next!=null){
            printData(node.next);
        }else{

        }
    }
}
